home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / hdf / unix / hdf3_2r2.lha / HDF3.2r2 / src / hkit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-28  |  20.7 KB  |  749 lines
  1. /***************************************************************************
  2. *
  3. *
  4. *                         NCSA HDF version 3.2r2
  5. *                            October 30, 1992
  6. *
  7. * NCSA HDF Version 3.2 source code and documentation are in the public
  8. * domain.  Specifically, we give to the public domain all rights for future
  9. * licensing of the source code, all resale rights, and all publishing rights.
  10. *
  11. * We ask, but do not require, that the following message be included in all
  12. * derived works:
  13. *
  14. * Portions developed at the National Center for Supercomputing Applications at
  15. * the University of Illinois at Urbana-Champaign, in collaboration with the
  16. * Information Technology Institute of Singapore.
  17. *
  18. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  19. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  20. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  21. *
  22. ****************************************************************************
  23. */
  24.  
  25. #ifdef RCSID
  26. static char RcsId[] = "@(#)$Revision: 1.5 $";
  27. #endif
  28. /*
  29. $Header: /hdf/hdf/v3.2r2/src/RCS/hkit.c,v 1.5 1992/10/23 00:14:11 koziol beta koziol $
  30.  
  31. $Log: hkit.c,v $
  32.  * Revision 1.5  1992/10/23  00:14:11  koziol
  33.  * Changed all DFIstr*() and DFImem*() calls to HDstr*() and HDmem*() calls
  34.  * #ifdef'd out the macros Jason defined for Hopen, Hclose, etc. for Vsets
  35.  * Replaced Vset VFREESPACE and VGETSPACE calls with actual calls to HDfreespace
  36.  * and HDgetspace
  37.  * Added a MS-Windows lower lower for file I/O (which may not be completely working
  38.  *
  39.  * Revision 1.3  1992/10/12  18:11:51  koziol
  40.  * Updated for v3.2r2 release
  41.  *
  42.  * Revision 1.2  1992/08/26  19:44:25  chouck
  43.  * Moved HDgettagname() into hkit.c and added calibration tag
  44.  *
  45.  * Revision 1.1  1992/08/25  21:40:44  koziol
  46.  * Initial revision
  47.  *
  48. */
  49. #include <ctype.h>
  50. #include "hdf.h"
  51. #include "herr.h"
  52. #include "hfile.h"
  53.  
  54. /*-----------------------------------------------------------------------------
  55.  * Name:    HIstrncpy
  56.  * Purpose: This function creates a string in dest that is at most
  57.  *          'len' characters long.  The 'len' characters *include* the
  58.  *          NULL terminatior which must be added for historical reasons.
  59.  *          So if you have the string "Foo\0" you must call this copy
  60.  *          function with len == 4
  61.  * Inputs:  dest, source: destination and source for copy
  62.  *          len: max length of the outgoing string
  63.  * Returns: Address of dest.
  64.  * Users:   HDF systems programmers
  65.  * Remarks:
  66.  *---------------------------------------------------------------------------*/
  67.  
  68. #if defined PROTOTYPE
  69. char *HIstrncpy(register char *dest,register char *source,int32 len)
  70. #else
  71. char *HIstrncpy(dest, source, len)
  72. register char *source, *dest;
  73. int32 len;
  74. #endif /* PROTOTYPE */
  75. {
  76.     char *destp;
  77.  
  78.     destp = dest;
  79.     if (len == 0) return(destp);
  80.     for(; (len > 1) && (*source != '\0');len--)
  81.         *dest++ = *source++;
  82.     *dest = '\0';       /* Force the last byte be '\0'   */
  83.     return(destp);
  84. }   /* end HIstrncpy() */
  85.  
  86. #ifdef PC
  87. #ifdef WIN3
  88. int32 HDspaceleft(void)
  89. {
  90. /* return the largest amount of memory Windows can give us */
  91.    return(GlobalCompact(0));
  92. }
  93. #else /* WIN3 */
  94. int32 HDspaceleft(void)
  95. {
  96.     struct _heapinfo h_info;        /* structure for heap information, defined in <malloc.h> */
  97.     int heap_status;                /* the current condition of the heap */
  98.     int32 total_free,total_used;    /* variables to store the amount used and the amount free in the heap */
  99.  
  100.     total_free=0;
  101.     total_used=0;
  102.     h_info._pentry=NULL;
  103.     for(;;) {
  104.         heap_status=_heapwalk(&h_info);
  105.         if(heap_status!=_HEAPOK)
  106.             break;
  107.         if(h_info._useflag==_USEDENTRY)
  108.             total_used+=h_info._size;
  109.         else
  110.             total_free+=h_info._size;
  111.     } /* end for */
  112.     switch(heap_status) {
  113.         case _HEAPEND:
  114.         case _HEAPEMPTY:
  115.             break;
  116.  
  117.         case _HEAPBADBEGIN:
  118.             printf("%s block at %Fp of size %4.4X\n",(h_info._useflag==_USEDENTRY ? "USED" : "FREE"),h_info._pentry,h_info._size);
  119.             printf("ERROR - heap is damaged\n\n");
  120.             return((int32)-1);
  121.  
  122.         case _HEAPBADPTR:
  123.             printf("%s block at %Fp of size %4.4X\n",(h_info._useflag==_USEDENTRY ? "USED" : "FREE"),h_info._pentry,h_info._size);
  124.             printf("ERROR - bad pointer to heap\n\n");
  125.             return((int32)-1);
  126.  
  127.         case _HEAPBADNODE:
  128.             printf("%s block at %Fp of size %4.4X\n",(h_info._useflag==_USEDENTRY ? "USED" : "FREE"),h_info._pentry,h_info._size);
  129.             printf("ERROR - bad node in heap\n\n");
  130.             return((int32)-1);
  131.     } /* end switch */
  132.     return((int32)total_free);
  133. } /* end HDspaceleft() */
  134. #endif /* WIN3 */
  135. #endif /* PC */
  136.  
  137.  
  138. #ifdef PC
  139. #ifdef WIN3
  140. void *HDgetspace(uint32 qty)
  141. {
  142.     char *FUNC="HDgetspace";
  143.  
  144.     HANDLE mem_handle;  /* handle of the memory allocated */
  145.     HANDLE *handle_addr;/* pointer to the HANDLE stored in the memory block */
  146.     char huge *p1;
  147.     char *p2;
  148.  
  149.     if (qty <= (uint32)128) {
  150.         mem_handle=LocalAlloc(LMEM_MOVEABLE, (WORD)qty+sizeof(HANDLE)+1);
  151.         if (mem_handle==NULL) {
  152.             HERROR(DFE_NOSPACE);
  153.             return(NULL);
  154.         }
  155.         handle_addr=(HANDLE *)(p2=(char *)LocalLock(mem_handle));
  156.         if (handle_addr==NULL) {
  157.             HERROR(DFE_NOSPACE);
  158.             return(NULL);
  159.         }
  160.         *handle_addr=mem_handle;
  161.         *((char *)handle_addr+sizeof(HANDLE))=0;
  162.         return (p2+sizeof(HANDLE)+1);
  163.     } else {
  164.         mem_handle=GlobalAlloc(GMEM_MOVEABLE,(DWORD)(qty+sizeof(HANDLE)+1));
  165.         if(mem_handle==NULL) {
  166.             HERROR(DFE_NOSPACE);
  167.             return(NULL);
  168.         }
  169.         /* lock down the block, use GlobalWire because we don't know how long */
  170.         /*  this potentially large block will be used */
  171.         handle_addr=(HANDLE *)(p1=(char huge *)GlobalWire(mem_handle));
  172.         if (handle_addr==NULL) {
  173.             HERROR(DFE_NOSPACE);
  174.             return(NULL);
  175.         }
  176.         *handle_addr=mem_handle;    /* store the handle in the first part of the memory block */
  177.         *((char *)handle_addr+sizeof(HANDLE))=1;
  178.         return(p1+sizeof(HANDLE)+1);
  179.     }
  180. }
  181.  
  182. void *HDfreespace(void *ptr)
  183. {
  184.     HANDLE mem_handle;  /* handle of the memory allocated */
  185.     HANDLE *handle_addr;/* pointer to the HANDLE stored in the memory block */
  186.  
  187.     if(ptr!=NULL) {
  188. /* get the address of the handle, which is stored in the memory block itself */
  189.         handle_addr=(HANDLE *)((char *)ptr-sizeof(HANDLE)-1);
  190.         mem_handle=*handle_addr;    /* get the handle from the memory block */
  191.         if (*((char *)ptr-1)) {
  192.             GlobalUnWire(mem_handle);     /* unlock the block */
  193.             GlobalFree(mem_handle);       /* free the block */
  194.         } else {
  195.             LocalUnlock(mem_handle);
  196.             LocalFree(mem_handle);
  197.         }
  198.     } /* end if */
  199.     return(NULL);
  200. }
  201. #else /* !WIN3 */
  202. void *HDgetspace(uint32 qty)
  203. {
  204.     char *FUNC="HDgetspace";
  205.     char huge *p;
  206.     char *p2;
  207.  
  208.     qty++;    /* increment the quantity to allocate to allow for the extra byte we are going to include */
  209.  
  210.     if(qty>=(int32)64000) {   /* see if we have to use halloc() to get a really large chunk of memory */
  211.         p = halloc((int32)qty,(size_t)1);
  212.         if (p==NULL) {
  213.             HERROR(DFE_NOSPACE);
  214.             return(NULL);
  215.           } /* end if */
  216.         *p=1;           /* indicate that halloc() was used to acquire this memory */
  217.         p++;
  218.         return((char huge *)p);
  219.       } /* end if */
  220.     else {      /* we can get away with just malloc() */
  221.         p2 = malloc((size_t)qty);
  222.         if (p2==NULL) {
  223.             HERROR(DFE_NOSPACE);
  224.             return(NULL);
  225.           } /* end if */
  226.         *p2=0;           /* indicate that malloc() was used to acquire this memory */
  227.         p2++;
  228.         return((char huge *)p2);
  229.       } /* end else */
  230. }
  231.  
  232. void *HDfreespace(void *ptr)
  233. {
  234.     if(ptr==NULL)
  235.         return(NULL);
  236.  
  237.     ptr = (char *)ptr-1;      /* decrement the pointer to free */
  238.     if(*(char *)ptr)   /* check whether block of memory was allocated with halloc() */
  239.         hfree(ptr);
  240.     else       /* memory was allocated through malloc() */
  241.         free(ptr);
  242.     return(NULL);
  243. }
  244. #endif /* WIN3 */
  245. #else /* PC */
  246.  
  247.  
  248. #if defined PROTOTYPE
  249. void *HDgetspace(uint32 qty)
  250. #else
  251. void *HDgetspace(qty)
  252. uint32 qty;
  253. #endif /* PROTOTYPE */
  254. {
  255.     char *FUNC="HDgetspace";
  256.     char *p;
  257.  
  258.     p = (char *) malloc(qty);
  259.     if (p== (char *) NULL) {
  260.         HERROR(DFE_NOSPACE);
  261.         HEreport("Attempted to allocate %d bytes", qty);
  262.         return(NULL);
  263.     }
  264.     return(p);
  265. }
  266.  
  267. #if defined PROTOTYPE
  268. void *HDfreespace(void *ptr)
  269. #else
  270. void *HDfreespace(ptr)
  271. void *ptr;
  272. #endif /* PROTOTYPE */
  273. {
  274.     if (ptr!=NULL) free(ptr);
  275.     return(NULL);
  276. }
  277.  
  278. #endif /* PC */
  279.  
  280. #if defined PROTOTYPE 
  281. intn HDc2fstr(char *str, int len)
  282. #else
  283. intn HDc2fstr(str, len)
  284. char* str;
  285. int len;
  286. #endif /* PROTOTYPE */
  287. {
  288.     int i;
  289.  
  290.     for(i=0; (str[i]); i++)
  291.         /* EMPTY */;
  292.     for(; i<len; i++) str[i] = ' ';
  293.     return 0;
  294. }
  295.  
  296. #if defined PROTOTYPE
  297. char *HDf2cstring(_fcd fdesc, intn len)
  298. #else
  299. char *HDf2cstring(fdesc, len)
  300.     _fcd fdesc;
  301.     intn len;
  302. #endif /* PROTOTYPE */
  303. {
  304.     char *cstr, *str;
  305.     int i;
  306.  
  307.     str = _fcdtocp(fdesc);
  308.     for(i=len-1;i>=0 && (!isascii(str[i]) || !isgraph(str[i])); i--)
  309.         /*EMPTY*/;
  310.     cstr = (char *)HDgetspace(i+2);
  311.     cstr[i+1] = '\0';
  312.     for (; i>=0; i--) cstr[i] = str[i];
  313.     return cstr;
  314. }
  315.  
  316. /*--------------------------------------------------------------------------
  317.  HIlookup_dd
  318.  
  319.  find the dd with tag and ref, by returning the block where the dd resides
  320.  and the index of the dd in the ddblock ddlist.
  321.  
  322.  This function is different from HIfind_dd in that it does not understand
  323.  any ordering in the file.  Wildcards sent to this routine (i.e. to
  324.  get the 'next' widget get passed off to HIfind_dd().
  325.  
  326.  Return FAIL or SUCCEED
  327. --------------------------------------------------------------------------*/
  328. #ifdef PROTOTYPE
  329. int HIlookup_dd(filerec_t *file_rec, uint16 look_tag, uint16 look_ref, 
  330.                 ddblock_t **pblock, int32 *pidx)
  331. #else
  332. int HIlookup_dd(file_rec, look_tag, look_ref, pblock, pidx)
  333.      filerec_t *file_rec;       /* the file */
  334.      uint16 look_tag;           /* tag of dd to look for */
  335.      uint16 look_ref;           /* ref of dd to look for */
  336.      ddblock_t **pblock;        /* OUT: ddblock where dd is found */
  337.      int32 *pidx;               /* OUT: index into ddlist where dd is found */
  338. #endif
  339. { 
  340.   char *FUNC="HIlookup_dd";       /* for HERROR */
  341.   register intn tag, ref, key;
  342.   register tag_ref_list_ptr p;
  343.  
  344.   if(look_tag == DFTAG_WILDCARD || look_ref == DFREF_WILDCARD)
  345.     return (HIfind_dd(look_tag, look_ref, pblock, pidx));
  346.  
  347.   tag = (intn) look_tag;
  348.   ref = (intn) look_ref;
  349.  
  350.   /*
  351.    * Look for the normal version 
  352.    */
  353.   key = tag + ref;
  354.  
  355.   for(p = file_rec->hash[key & HASH_MASK]; p; p = p->next) {
  356.     if(p->tag == tag && p->ref == ref) {
  357.       *pblock = p->pblock;
  358.       *pidx   = p->pidx;
  359.       return SUCCEED;
  360.     }
  361.   }
  362.  
  363.   /*
  364.    * Try looking for the special version of this tag
  365.    */
  366.   tag = (intn) MKSPECIALTAG(look_tag);
  367.   key = tag + ref;
  368.  
  369.   for(p = file_rec->hash[key & HASH_MASK]; p; p = p->next) {
  370.     if(p->tag == tag && p->ref == ref) {
  371.       *pblock = p->pblock;
  372.       *pidx   = p->pidx;
  373.       return SUCCEED;
  374.     }
  375.   }
  376.  
  377.   return FAIL;
  378.  
  379. } /* HIlookup_dd */
  380.  
  381. /* ---------------------------- HIadd_hash_dd ----------------------------- */
  382. /*
  383.   Add a new dd into the hash table
  384.  
  385.   Return SUCCEED or FAIL
  386. */
  387. #ifdef PROTOTYPE
  388. int HIadd_hash_dd(filerec_t *file_rec, uint16 look_tag, uint16 look_ref, 
  389.                 ddblock_t *pblock, int32 pidx)
  390. #else
  391. int HIadd_hash_dd(file_rec, look_tag, look_ref, pblock, pidx)
  392.      filerec_t *file_rec;      /* the file */
  393.      uint16 look_tag;           /* tag of dd to add */
  394.      uint16 look_ref;           /* ref of dd to add */
  395.      ddblock_t *pblock;         /* ddblock where dd is  */
  396.      int32 pidx;                /* index into ddlist where dd is */
  397. #endif
  398. {
  399.   char *FUNC="HIadd_hash_dd";       /* for HERROR */
  400.   register intn tag, ref, key;
  401.   register tag_ref_list_ptr p;
  402.  
  403.   if(look_tag == DFTAG_NULL) return SUCCEED;
  404.  
  405.   tag = (intn) look_tag;
  406.   ref = (intn) look_ref;
  407.   key = tag + ref;
  408.  
  409.   if(!(p = (tag_ref_list_ptr) HDgetspace((uint32)sizeof(tag_ref_list))))
  410.     HRETURN_ERROR(DFE_NOSPACE, FAIL);
  411.   
  412.   p->pblock = pblock;
  413.   p->pidx   = pidx;
  414.   p->tag    = tag;
  415.   p->ref    = ref;
  416.   p->next   = file_rec->hash[key & HASH_MASK];        
  417.   file_rec->hash[key & HASH_MASK] = p;
  418.   
  419.   return SUCCEED;
  420.  
  421. } /* HIadd_hash_dd */
  422.  
  423.  
  424. /* ---------------------------- HIdel_hash_dd ----------------------------- */
  425. /*
  426.   Delete a dd from the hash table
  427.  
  428.   Return SUCCEED or FAIL
  429. */
  430. #ifdef PROTOTYPE
  431. int HIdel_hash_dd(filerec_t *file_rec, uint16 look_tag, uint16 look_ref)
  432. #else
  433. int HIdel_hash_dd(file_rec, look_tag, look_ref)
  434.      filerec_t *file_rec;      /* the file */
  435.      uint16 look_tag;           /* tag of dd to add */
  436.      uint16 look_ref;           /* ref of dd to add */
  437. #endif
  438. {
  439.   char *FUNC="HIdel_hash_dd";       /* for HERROR */
  440.   register intn tag, ref, key;
  441.   register tag_ref_list_ptr p, prev;
  442.  
  443.   tag = (intn) look_tag;
  444.   ref = (intn) look_ref;
  445.   key = tag + ref;
  446.   
  447.   p = file_rec->hash[key & HASH_MASK]; 
  448.  
  449.   if(!p) return SUCCEED;
  450.  
  451.   prev = NULL;
  452.   for(p = file_rec->hash[key & HASH_MASK]; p; p = p->next) {
  453.     if(p->tag == tag && p->ref == ref) {
  454.       if(prev)
  455.         prev->next = p->next;
  456.       else
  457.         file_rec->hash[key & HASH_MASK] = p->next;
  458.  
  459.       HDfreespace(p);
  460.       return SUCCEED;
  461.     }
  462.     prev = p;
  463.   }
  464.  
  465.   return SUCCEED;
  466.  
  467. } /* HIdel_hash_dd */
  468.  
  469.  
  470. /*--------------------------------------------------------------------------
  471.  HIfind_dd
  472.  
  473.  find the dd with tag and ref, by returning the block where the dd resides
  474.  and the index of the dd in the ddblock ddlist.
  475. --------------------------------------------------------------------------*/
  476. #ifdef PROTOTYPE
  477. int HIfind_dd(uint16 look_tag, uint16 look_ref, ddblock_t **pblock, int32 *pidx)
  478. #else
  479. int HIfind_dd(look_tag, look_ref, pblock, pidx)
  480.     uint16 look_tag;           /* tag of dd to look for */
  481.     uint16 look_ref;           /* ref of dd to look for */
  482.     ddblock_t **pblock;        /* IN: ddblock to start looking for the dd */
  483.                                /* OUT: ddblock where dd is found */
  484.     int32 *pidx;               /* IN: index before place in ddlist
  485.                                   to start searching */
  486.                                /* OUT: index into ddlist where dd is found */
  487. #endif
  488. {
  489.     register int32 idx;             /* index into ddlist of current dd searched */
  490.     register ddblock_t *block;      /* ptr to current ddblock searched */
  491.     register dd_t *list;            /* ptr to current ddlist searched */
  492.  
  493. #ifndef oldspecial
  494.     uint16 special_tag;                /* corresponding special tag */
  495.  
  496.     /* search for special version also */
  497.  
  498.     special_tag = MKSPECIALTAG(look_tag);
  499. #endif
  500.  
  501.     /* start searching on the next dd */
  502.     idx = *pidx + 1;
  503.     for (block = *pblock; block; block = block->next) {
  504.  
  505.        list = block->ddlist;
  506.        for (; idx < block->ndds; idx++) {
  507.  
  508.            /* skip the empty dd's */
  509.  
  510.            if (list[idx].tag == DFTAG_NULL && look_tag != DFTAG_NULL)
  511.                continue;
  512.  
  513.            if(((look_tag == DFTAG_WILDCARD || list[idx].tag == look_tag)
  514. #ifndef oldspecial
  515.                 || (special_tag != DFTAG_NULL && list[idx].tag == special_tag)
  516. #endif
  517.               ) && (look_ref == DFREF_WILDCARD || list[idx].ref == look_ref)) {
  518.  
  519.                /* we have a match !! */
  520.  
  521.                *pblock = block;
  522.                *pidx = idx;
  523.                return SUCCEED;
  524.            }
  525.        }
  526.  
  527.        /* start from beginning of the next dd list */
  528.  
  529.        idx = 0;
  530.     }
  531.  
  532.     /* nothing found */
  533.  
  534.     return FAIL;
  535. } /* HIfind_dd */
  536.  
  537. /* ------------------------------- HDflush -------------------------------- */
  538. /*
  539.  
  540.   Force the system to flush the HDF file stream
  541.  
  542.   This should be primarily used for debugging
  543.  
  544.   The MAC does not really support fflush() so this routine just returns
  545.     SUCCEED always on a MAC w/o really doing anything.
  546.  
  547. */
  548.  
  549. #ifdef PROTOTYPE
  550. intn HDflush(int32 file_id)
  551. #else
  552. intn HDflush(file_id)
  553.     int32 file_id;             /* id of file to flush */
  554. #endif
  555. {
  556.     char *FUNC="HDflush";       /* for HERROR */
  557.  
  558. #ifndef MAC
  559.  
  560.     filerec_t *file_rec;
  561.     
  562.     file_rec = FID2REC(file_id);
  563.     if (!file_rec || file_rec->refcount == 0) {
  564.         HERROR(DFE_ARGS);
  565.         return FAIL;
  566.     }
  567.     
  568.     fflush(file_rec->file);
  569.  
  570. #endif /* MAC */
  571.  
  572.     return SUCCEED;
  573.  
  574. } /* HDflush */
  575.  
  576.  
  577. /* ---------------------------- HDpackFstring ----------------------------- */
  578. /*
  579.  
  580.   HDpackFstring -- given a NULL terminated C string 'src' convert it to
  581.   a space padded Fortran string 'dest' of length 'len'
  582.  
  583. */
  584. intn
  585. #ifdef PROTOTYPE
  586. HDpackFstring(char *src, char *dest, intn len)
  587. #else
  588. HDpackFstring(src, dest, len)
  589. char *src, *dest;
  590. intn len;
  591. #endif
  592. {
  593.  
  594.     intn sofar;
  595.     
  596.     for(sofar = 0; (sofar < len) && (*src != '\0'); sofar++)
  597.         *dest++ = *src++;
  598.  
  599.     while(sofar++ < len)
  600.         *dest++ = ' ';
  601.  
  602.     return SUCCEED;
  603.  
  604. }
  605.  
  606.  
  607. /*--------------------------------------------------------------------------
  608.  *  HDgettagname(tag) : map a tag to its corresponding name
  609.  *                      return NULL if tag is unknown.
  610.  *
  611.  *  NOTE: Please keep tag names <= 30 characters - a 
  612.  *        lot of pretty-printing code depends on it.
  613. --------------------------------------------------------------------------*/
  614. #ifdef PROTOTYPE
  615. char *HDgettagname(uint16 tag)
  616. #else
  617. char *HDgettagname(tag)
  618.      uint16 tag;
  619. #endif /* PROTOTYPE */
  620. {
  621.  
  622.   char *name;
  623.  
  624.   switch(tag) {
  625.       
  626.       /* Utility Tags */
  627.   case DFTAG_NULL  :
  628.       name = "No Data"; break;
  629.   case DFTAG_VERSION :
  630.       name = "Version Descriptor"; break;
  631.   case DFTAG_LINKED :
  632.       name = "Linked Blocks Indicator"; break;
  633.   case DFTAG_FID   : 
  634.       name = "File Identifier"; break;
  635.   case DFTAG_FD    :   
  636.       name = "File Description"; break;
  637.   case DFTAG_TID   :
  638.       name = "Tag Identifier"; break;
  639.   case DFTAG_TD    : 
  640.       name = "Tag Description"; break;
  641.   case DFTAG_DIL   :
  642.       name = "Data Id Label"; break;
  643.   case DFTAG_DIA   :    
  644.       name = "Data Id Annotation"; break;
  645.   case DFTAG_NT    :    
  646.       name = "Number type"; break;
  647.   case DFTAG_MT    :   
  648.       name = "Machine type"; break;
  649.       
  650.       /* raster-8 Tags */
  651.   case DFTAG_ID8   :   
  652.       name = "Image Dimensions-8"; break;
  653.   case DFTAG_IP8   :   
  654.       name = "Image Palette-8"; break;
  655.   case DFTAG_RI8   :  
  656.       name = "Raster Image-8"; break;
  657.   case DFTAG_CI8   : 
  658.       name = "RLE Compressed Image-8"; break;
  659.   case DFTAG_II8   :  
  660.       name = "Imcomp Image-8"; break;
  661.       
  662.       /* Raster Image Tags */
  663.   case DFTAG_ID    :  
  664.       name = "Image Dimensions"; break;
  665.   case DFTAG_LUT   :  
  666.       name = "Image Palette"; break;
  667.   case DFTAG_RI    : 
  668.       name = "Raster Image Data"; break;
  669.   case DFTAG_CI    :  
  670.       name = "Compressed Image"; break;
  671.   case DFTAG_RIG   : 
  672.       name = "Raster Image Group"; break;
  673.   case DFTAG_LD    : 
  674.       name = "Palette Dimension"; break;
  675.   case DFTAG_MD    :
  676.       name = "Matte Dimension"; break;
  677.   case DFTAG_MA    :
  678.       name = "Matte Data"; break;
  679.   case DFTAG_CCN   :   
  680.       name = "Color Correction"; break;
  681.   case DFTAG_CFM   : 
  682.       name = "Color Format"; break;
  683.   case DFTAG_AR    :   
  684.       name = "Aspect Ratio"; break;
  685.   case DFTAG_DRAW  :
  686.       name = "Sequenced images"; break;
  687.   case DFTAG_RUN   :   
  688.       name = "Runable program / script"; break;
  689.   case DFTAG_XYP   : 
  690.       name = "X-Y position"; break;
  691.   case DFTAG_MTO   :  
  692.       name = "M/c-Type override"; break;
  693.       
  694.       /* Tektronix */
  695.   case DFTAG_T14   :   
  696.       name = "TEK 4014 Data"; break;
  697.   case DFTAG_T105  :
  698.       name = "TEK 4105 data"; break;
  699.       
  700.       /* Compression Schemes */
  701.   case DFTAG_RLE   : 
  702.       name = "Run Length Encoding"; break;
  703.   case DFTAG_IMCOMP : 
  704.       name = "IMCOMP Encoding"; break;
  705.       
  706.       /* Scientific / Numeric Data Sets */
  707.   case DFTAG_SDG   : 
  708.       name = "Scientific Data Group"; break;
  709.   case DFTAG_NDG   : 
  710.       name = "Numeric Data Group"; break;
  711.   case DFTAG_SD    :
  712.       name = "Scientific Data"; break;
  713.   case DFTAG_SDD   : 
  714.     name = "SciData description"; break;
  715.   case DFTAG_SDL   :   
  716.       name = "SciData labels"; break;
  717.   case DFTAG_SDU   : 
  718.       name = "SciData units"; break;
  719.   case DFTAG_SDF   :  
  720.       name = "SciData formats"; break;
  721.   case DFTAG_SDS   :  
  722.       name = "SciData scales"; break;
  723.   case DFTAG_SDM   :  
  724.       name = "SciData max/min"; break;
  725.   case DFTAG_SDC   :  
  726.       name = "SciData coordsys"; break;
  727.   case DFTAG_SDT   :  
  728.       name = "Transpose"; break;
  729.   case DFTAG_SDLNK :  
  730.       name = "Links related to the dataset"; break;
  731.   case DFTAG_CAL   :  
  732.       name = "Calibration information"; break;
  733.       
  734.       /* V Group Tags */
  735.   case DFTAG_VG   :  
  736.       name = "Vgroup"; break;
  737.   case DFTAG_VH   : 
  738.       name = "Vdata"; break;
  739.   case DFTAG_VS   : 
  740.       name = "Vdata Storage"; break;
  741.   default:
  742.       name = (char *) NULL;
  743.       break;
  744.   }
  745.   
  746.   return name;
  747.   
  748. }
  749.